/*
 * IkaSprite.cpp
 */

#include "IkaSprite.h"

using namespace atomic;

namespace data {

IkaSprite::IkaSprite() : IkaCore() {
	IkaPoint myOffSet(0.f, 0.f);
	IkaPoint myVelocity(0.f, 0.f);
	IkaPoint myAcceleration(0.f, 0.f);
	IkaPoint myDrag(0.f, 0.f);
	IkaPoint myMaxVelocity(0.f, 0.f);
	myAngle = 0.f;
	myAngularVelocity = 0.f;
	myAngularAcceleration = 0.f;
	myAngularDrag = 0.f;
	myMaxAngular = 2.f;
	myThrust = 1.f;
	myMaxTrust = 10.f;
	myHealth  = 100.f;
	isFinished = false;
	isFacingRight = false;
	atomic::IkaArray<atomic::IkaAnim> myAnims();
}


IkaSprite::~IkaSprite() {
	//delete[] myAnims;
}


IkaSprite::IkaSprite(const data::IkaSprite &copy) : IkaCore(copy) {
	this->myOffSet = copy.myOffSet;
	this->myVelocity = copy.myVelocity;
	this->myAcceleration = copy.myAcceleration;
	this->myDrag = copy.myDrag;
	this->myMaxVelocity = copy.myMaxVelocity;
	this->myAngle = copy.myAngle;
	this->myAngularVelocity = copy.myAngularVelocity;
	this->myAngularAcceleration = copy.myAngularAcceleration;
	this->myAngularDrag = copy.myAngularDrag;
	this->myMaxAngular = copy.myMaxAngular;
	this->myThrust = copy.myThrust;
	this->myMaxTrust = copy.myMaxTrust;
	this->myHealth = copy.myHealth;
	this->isFinished = copy.isFinished;
	this->isFacingRight = copy.isFacingRight;
	this->myAnims = copy.myAnims;
}

// IkaSprite::IkaSprite(float x, float y, atomic::IkaAnim graphic,
// 		bool animated, bool reverse, unsigned int width, unsigned int height,
// 		unsigned int color) : IkaCore(x,y,graphic) {
// }

void IkaSprite::Update() {
}

void IkaSprite::Init() {
}

void IkaSprite::Hurt(float damages) {

}

void IkaSprite::OverLapArray(data::IkaSprite sprites[]) {

}

void IkaSprite::OverLapArrays(data::IkaSprite sprites1[],
		data::IkaSprite sprites2[]) {

}

void IkaSprite::AddAnimation(std::string name, atomic::IkaGraphic frames[],
		float frameRate, bool looped) {

}

void IkaSprite::Play(std::string animName, bool forced) {

}

void IkaSprite::Facing(bool isRight){

}

void IkaSprite::RandomFrame(){

}

bool IkaSprite::FacingRight() {
	return this->isFacingRight;
}

bool IkaSprite::Finished() {
	return isFinished;
}

atomic::IkaPoint IkaSprite::Acceleration() {
	return myAcceleration;
}

float IkaSprite::Angle() {
	return myAngle;
}

float IkaSprite::AngularAcceleration() {
	return myAngularAcceleration;
}

float IkaSprite::AngularDrag() {
	return myAngularDrag;
}

float IkaSprite::AngularVelocity() {
	return myAngularVelocity;
}

atomic::IkaPoint IkaSprite::Drag() {
	return myDrag;
}

float IkaSprite::Health() {
	return myHealth;
}

float IkaSprite::MaxAngular() {
	return myMaxAngular;
}

float IkaSprite::MaxTrust() {
	return myMaxTrust;
}

atomic::IkaPoint IkaSprite::MaxVelocity() {
	return myMaxVelocity;
}

atomic::IkaPoint IkaSprite::OffSet() {
	return myOffSet;
}

float IkaSprite::Thrust() {
	return myThrust;
}

atomic::IkaPoint IkaSprite::Velocity() {
	return myVelocity;
}

void IkaSprite::SetFacingRight(bool facingRight) {
	this->isFacingRight = facingRight;
}

void IkaSprite::SetFinished(bool finished) {
	this->isFinished = finished;
}

void IkaSprite::SetAcceleration(atomic::IkaPoint acceleration) {
	this->myAcceleration = acceleration;
}

void IkaSprite::SetAngle(float angle) {
	this->myAngle = angle;
}

void IkaSprite::SetAngularAcceleration(float angularAcceleration) {
	this->myAngularAcceleration = angularAcceleration;
}

void IkaSprite::SetAngularDrag(float angularDrag) {
	this->myAngularDrag = angularDrag;
}

void IkaSprite::SetAngularVelocity(float angularVelocity) {
	this->myAngularVelocity = angularVelocity;
}

void IkaSprite::SetAnims(atomic::IkaAnim anims[]) {
	//this->myAnims = anims;
}

void IkaSprite::SetDrag(atomic::IkaPoint drag) {
	this->myDrag = drag;
}

void IkaSprite::SetHealth(float health) {
	this->myHealth = health;
}

void IkaSprite::SetMaxAngular(float maxAngular) {
	this->myMaxAngular = maxAngular;
}

void IkaSprite::SetMaxTrust(float maxTrust) {
	this->myMaxTrust = maxTrust;
}

void IkaSprite::SetMaxVelocity(atomic::IkaPoint maxVelocity) {
	this->myMaxVelocity = maxVelocity;
}

void IkaSprite::SetOffSet(atomic::IkaPoint offSet) {
	this->myOffSet = offSet;
}

void IkaSprite::SetThrust(float thrust) {
	this->myThrust = thrust;
}

void IkaSprite::SetVelocity(atomic::IkaPoint velocity) {
	this->myVelocity = velocity;
}

}
